// Contient toutes les spécifications de classes nécessaires pour représenter l'arbre abstrait
#ifndef ARBRE_H_
#define ARBRE_H_


#include <vector>
#include <iostream>
#include <iomanip>
#include "Symbole.h"
#include "Exception.h"

////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe Noeud
Décrit la liste des méthodes et attributs associés à la classe Noeud
\author Inconnu
\date 03.01.2012
*/
/*! \class Noeud
\brief La classe représentant les noeuds.
Cette classe permet de représenter sous la forme d'un objet
une variable de type Noeud. Les méthodes suivantes sont associées
à un objet de type Noeud :
\li getValeur
\li afficher
\li translateAda
*/

class Noeud {
// classe abstraite dont dériveront toutes les classes servant à représenter l'arbre abstrait
// Remarque : la classe ne contient aucun constructeur
  public:
    virtual int  getValeur() =0 ; // méthode pure (non implémentée) qui rend la classe abstraite
    virtual void afficher(unsigned short indentation=0) { cout << setw(4*indentation) << " "; }
      // pour afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
    virtual void translateAda(unsigned short indentation=0) { cout << setw(4*indentation) << " "; }
    // permet de traduire en langage ada, le langage initialement proposé
    virtual ~Noeud() {} // présence d'un destructeur virtuel conseillée dans les classes abstraites
};

////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe NoeudSeqInst
Décrit la liste des méthodes et attributs associés à la classe NoeudSeqInst
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudSeqInst
\brief La classe représentant les noeuds pour les sequences d'instruction.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudSeqInst. Les méthodes suivantes sont associées
à un objet de type NoeudSeqInst :
\li getValeur
\li afficher
\li ajouteInstruction
\li translateAda
*/

class NoeudSeqInst : public Noeud {
// classe pour représenter un noeud "sequence d'instruction"
// qui a autant de fils que d'instructions dans la séquence
  public:
     NoeudSeqInst();   // construit une séquence d'instruction vide
    ~NoeudSeqInst() {} // à cause du destructeur virtuel de la classe Noeud
    int getValeur(); // évalue chaque instruction de la séquence
    void afficher(unsigned short indentation=0); // affiche la séquence d'instructions
    void ajouteInstruction(Noeud* instruction);  // ajoute une instruction à la séquence

  private:
    /*! \var vector<Noeud *> tabInst
    \brief Stocke les instructions de la séquence
    */
    vector<Noeud *> tabInst; 
};

////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe NoeudAffectation
Décrit la liste des méthodes et attributs associés à la classe NoeudAffectation
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudAffectation
\brief La classe représentant les noeuds pour les affectations.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudAffectation. Les méthodes suivantes sont associées
à un objet de type NoeudAffectation :
\li getValeur
\li afficher
\li translateAda
*/

class NoeudAffectation : public Noeud {
// classe pour représenter un noeud "affectation"
// composé de 2 fils : la variable et l'expression qu'on lui affecte
  public:
     NoeudAffectation(Noeud* variable, Noeud* expression); // construit une affectation
    ~NoeudAffectation() {} // à cause du destructeur virtuel de la classe Noeud
    int getValeur(); // évalue l'expression et affecte sa valeur à la variable
    void afficher(unsigned short indentation=0); // affiche l'affectation
    void translateAda(unsigned short indentation=0); // traduit en Ada le language utilisé

  private
    /*! \var Noeud* variable
    \brief variable de type noeud
    */
    Noeud* variable;
      
    /*! \var Noeud* expression
    \brief expression de type noeud
    */
    Noeud* expression;
};

////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe NoeudOperateurBinaire
Décrit la liste des méthodes et attributs associés à la classe NoeudOperateurBinaire
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudOperateurBinaire
\brief La classe représentant les noeuds pour les opérateurs binaires.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudOperateurBinaire. Les méthodes suivantes sont associées
à un objet de type NoeudOperateurBinaire :
\li getValeur
\li afficher
\li translateAda
*/

class NoeudOperateurBinaire : public Noeud {
// classe pour représenter un noeud "opération arithmétique" composé d'un opérateur (+-*/)
// et de 2 fils : l'opérande gauche et l'opérande droit
  public:
    NoeudOperateurBinaire(Symbole operateur, Noeud* operandeGauche, Noeud* operandeDroit);
     // construit une opération binaire : operandeGauche operateur OperandeDroit
   ~NoeudOperateurBinaire() {} // à cause du destructeur virtuel de la classe Noeud
    int getValeur(); // évalue l'operande gauche, l'operande droit et applique l'opérateur
    void afficher(unsigned short indentation=0); // affiche l'opération
    void translateAda(unsigned short indentation=0); // traduit en Ada le language utilisé
    
  private:
      /*! \var Symbole operateur
    \brief operateur de type symbole
    */
    Symbole operateur;
    
    /*! \var Noeud* operandeGauche
    \brief operandeDroit de type noeud
    */
    Noeud*  operandeGauche;
    
    /*! \var Noeud* operandeDroit
    \brief operandeDroit de type noeud
    */
    Noeud*  operandeDroit;
};

////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe NoeudInstSi
Décrit la liste des méthodes et attributs associés à la classe NoeudInstSi
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudInstSi
\brief La classe représentant les noeuds pour les instructions si.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudInstSi. Les méthodes suivantes sont associées
à un objet de type NoeudInstSi :
\li getValeur
\li afficher
\li translateAda
*/

class NoeudInstSi : public Noeud {
// classe pour représenter un noeud "instruction si"
// composé de 2 fils : l'expression et la séquence qu'on lui affecte
  public:
     NoeudInstSi();                              // construit une instruction si
    ~NoeudInstSi() {}                            // à cause du destructeur virtuel de la classe Noeud
    void ajouterExpBool(Noeud* expBool);
    void ajouterSeqInst(Noeud* seqInst);
    vector<Noeud*> getTabExpBool();
    vector<Noeud*> getTabSeqInst();
    int getValeur();
    void afficher(unsigned short indentation=0); // affiche l'opération
    void translateAda(unsigned short indentation=0); // traduit en Ada le language utilisé
    
  private:
    /*! \var vector<Noeud *> tabExpBool
    \brief Stocke les expressions booléennes
    */
    vector<Noeud*> tabExpBool;
    
    /*! \var vector<Noeud *> tabSeqInst
    \brief Stocke les instructions de la séquence
    */
    vector<Noeud*> tabSeqInst;
};

////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe NoeudInstTq
Décrit la liste des méthodes et attributs associés à la classe NoeudInstTq
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudInstTq
\brief La classe représentant les noeuds pour les instructions tant que.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudInstTq. Les méthodes suivantes sont associées
à un objet de type NoeudInstTq :
\li getValeur
\li afficher
\li getExpBool
\li getSeqInst
\li translateAda
*/

class NoeudInstTq : public Noeud {
// classe pour représenter un noeud "instruction tant que"
// composé de 2 fils : l'expression booléenne et la séquence d'instruction qu'on lui affecte
  public:
     NoeudInstTq(Noeud* expBool, Noeud* seqInst); // construit une instruction tant que
    ~NoeudInstTq() {}                             // à cause du destructeur virtuel de la classe Noeud
    int getValeur();                              // évalue l'operande gauche, l'operande droit et applique l'opérateur
    void afficher(unsigned short indentation=0);  // affiche l'opération
    Noeud* getExpBool();
    Noeud* getSeqInst();

  private:
    /*! \var Noeud* expBool
    \brief Stocke les expressions booléennes
    */
    Noeud* expBool;
    
    /*! \var Noeud* seqInst
    \brief Stocke les instructions de la séquence
    */
    Noeud* seqInst;
};



////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
    \brief La spécification de la classe NoeudInstRepeter
Décrit la liste des méthodes et attributs associés à la classe NoeudInstRepeter
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudInstRepeter
\brief La classe représentant les noeuds pour les instructions repeter.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudInstRepeter. Les méthodes suivantes sont associées
à un objet de type NoeudInstRepeter :
\li getValeur
\li afficher
\li translateAda
*/

class NoeudInstRepeter : public NoeudInstTq {
// classe pour représenter un noeud "instruction répéter", classe fille de la classe tant que

  public:
     NoeudInstRepeter(Noeud* expBool, Noeud* seqInst); // construit une instruction répéter
    ~NoeudInstRepeter() {}                             // à cause du destructeur virtuel de la classe Noeud
    int getValeur();                                   // évalue l'operande gauche, l'operande droit et applique l'opérateur
    void afficher(unsigned short indentation=0);       // affiche l'opération

};



////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe NoeudInstPour
Décrit la liste des méthodes et attributs associés à la classe NoeudInstPour
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudInstPour
\brief La classe représentant les noeuds pour les instructions pour.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudInstPour. Les méthodes suivantes sont associées
à un objet de type NoeudInstPour :
\li getValeur
\li afficher
\li translateAda
*/

class NoeudInstPour : public Noeud {
// classe pour représenter un noeud "instruction pour"
// composé de 4 fils : une premiere affectation, une expression booléenne, une deuxieme affectation 
// et une sequence d'instruction qu'on lui affecte.
    
  public:
     NoeudInstPour(Noeud* affectation1, Noeud* expBool, Noeud* affectation2, Noeud* seqInst); // construit une instruction pour
    ~NoeudInstPour() {}                           // à cause du destructeur virtuel de la classe Noeud
    int getValeur();                              // évalue l'operande gauche, l'operande droit et applique l'opérateur
    void afficher(unsigned short indentation=0);  // affiche l'opération
    void translateAda(unsigned short indentation=0); // traduit en Ada le language utilisé

  private:
    /*! \var Noeud* affectation1
    \brief affectation1 de type noeud
    */      
    Noeud* affectation1;
    
    /*! \var Noeud* expBool
    \brief expBool de type noeud
    */
    Noeud* expBool;
    
    /*! \var Noeud* affectation2
    \brief affectation2 de type noeud
    */
    Noeud* affectation2;
    
    /*! \var Noeud* seqInst
    \brief seqInst de type noeud
    */
    Noeud* seqInst;
};



////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe NoeudInstLire
Décrit la liste des méthodes et attributs associés à la classe NoeudInstLire
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudInstLire
\brief La classe représentant les noeuds pour les instructions lire.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudInstLire. Les méthodes suivantes sont associées
à un objet de type NoeudInstLire :
\li getValeur
\li afficher
\li translateAda
*/

class NoeudInstLire : public Noeud {
// classe pour représenter un noeud "instruction lire"
// composé de 1 fils : une variable qu'on lui affecte
  public:
     NoeudInstLire(Noeud* variable);              // construit une instruction lire
    ~NoeudInstLire() {}                           // à cause du destructeur virtuel de la classe Noeud
     int getValeur();                             // évalue l'operande gauche, l'operande droit et applique l'opérateur
     void afficher(unsigned short indentation=0); // affiche l'opération
     void translateAda(unsigned short indentation=10); // traduit en Ada le language utilisé

  private:
    /*! \var Noeud* variable
    \brief variable de type noeud
    */  
    Noeud* variable;
};



////////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe NoeudInstEcrire
Décrit la liste des méthodes et attributs associés à la classe NoeudInstEcrire
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudInstEcrire
\brief La classe représentant les noeuds pour les instructions ecrire.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudInstEcrire. Les méthodes suivantes sont associées
à un objet de type NoeudInstEcrire :
\li getValeur
\li afficher
\li translateAda
*/

class NoeudInstEcrire : public Noeud {
// classe pour représenter un noeud "instruction ecrire"
// composé de 2 fils : une expression et une chaine qu'on lui affecte
  public:
     NoeudInstEcrire(Noeud* expression);          // construit une instruction ecrire
    ~NoeudInstEcrire() {}                         // à cause du destructeur virtuel de la classe Noeud
     int getValeur();                             // évalue l'operande gauche, l'operande droit et applique l'opérateur
     void afficher(unsigned short indentation=0); // affiche l'opération
     void translateAda(unsigned short indentation=0); // traduit en Ada le language utilisé

  private:
    /*! \var Noeud* expression
    \brief expression de type noeud
    */    
    Noeud* expression;
};

///////////////////////////////////////////////////////////////////////////////
/*! \file Arbre.h
\brief La spécification de la classe NoeudInstSelon
Décrit la liste des méthodes et attributs associés à la classe NoeudInstSelon
\author Inconnu
\date 03.01.2012
*/
/*! \class NoeudInstSelon
\brief La classe représentant les noeuds pour les instructions selon.
Cette classe permet de représenter sous la forme d'un objet
une variable de type NoeudInstSelon. Les méthodes suivantes sont associées
à un objet de type NoeudInstSelon :
\li afficher
\li getValeur
\li translateAda
*/

class NoeudInstSelon : public NoeudInstSi {
// classe pour représenter un noeud "instruction selon", classe fille de la classe Ssi
// composé de 1 fils : une variable qu'on lui affecte
public :
    NoeudInstSelon(Noeud* variable);                 // construit une instruction selonq
    ~NoeudInstSelon() {}                             // à cause du destructeur virtuel de la classe Noeud
    void afficher(unsigned short indentation=0);     // affiche l'opération
    int getValeur();                                 // évalue l'operande gauche, l'operande droit et applique l'opérateur
    void translateAda(unsigned short indentation=0); // traduit en Ada le language utilisé

private:
    /*! \var Noeud* variable
    \brief variable de type noeud
    */  
    Noeud* variable;
};

#endif /* ARBRE_H_ */
